// API服务类 - 处理腾讯ASR和ChatGPT API调用
class APIService {
    constructor() {
        this.config = window.CONFIG || CONFIG;
        this.asrWebSocket = null;
        this.isASRConnected = false;
        
        // 事件回调
        this.onRecognitionResult = null;
        this.onSentenceEnd = null;
        this.onRecognitionComplete = null;
        this.onError = null;
        this.onConnected = null;
        this.onAudioData = null; // 音频数据回调
    }

    // 初始化腾讯ASR WebSocket
    initTencentASR() {
        if (this.asrWebSocket) {
            return this.asrWebSocket;
        }

        this.asrWebSocket = new TencentASRWebSocket(this.config.TENCENT_ASR);
        
        // 设置事件回调
        this.asrWebSocket.onConnected = (voiceId) => {
            console.log('ASR WebSocket连接成功:', voiceId);
            this.isASRConnected = true;
        };

        this.asrWebSocket.onRecognitionResult = (result) => {
            console.log('API服务收到识别结果:', result);
            // 这里可以触发实时转写更新
            if (this.onRecognitionResult) {
                console.log('调用外部识别结果回调');
                this.onRecognitionResult(result);
            } else {
                console.warn('未设置识别结果回调函数');
            }
        };

        this.asrWebSocket.onSentenceEnd = (result) => {
            console.log('API服务收到句子结束:', result);
            // 这里可以触发句子完成处理
            if (this.onSentenceEnd) {
                console.log('调用外部句子结束回调');
                this.onSentenceEnd(result);
            } else {
                console.warn('未设置句子结束回调函数');
            }
        };

        this.asrWebSocket.onRecognitionComplete = (voiceId) => {
            console.log('识别完成:', voiceId);
            this.isASRConnected = false;
        };

        this.asrWebSocket.onError = (error) => {
            console.error('ASR WebSocket错误:', error);
            this.isASRConnected = false;
            if (this.onError) {
                this.onError(error);
            }
        };

        this.asrWebSocket.onAudioData = (audioData, id) => {
            console.log('API服务收到音频数据:', audioData.byteLength, 'bytes');
            var audiojson = {
                data: audioData,
                id: id
            };
            if (this.onAudioData) {
                this.onAudioData(audiojson);
            }
        };

        return this.asrWebSocket;
    }

    // 开始实时ASR识别
    async startRealTimeASR() {
        try {
            const asr = this.initTencentASR();
            await asr.startRecording();
            return true;
        } catch (error) {
            console.error('启动实时ASR失败:', error);
            return false;
        }
    }

    // 停止实时ASR识别
    stopRealTimeASR() {
        if (this.asrWebSocket) {
            this.asrWebSocket.stopRecording();
        }
    }

    // 清理ASR资源
    cleanupASR() {
        if (this.asrWebSocket) {
            this.asrWebSocket.cleanup();
            this.asrWebSocket = null;
        }
        this.isASRConnected = false;
    }

    // 腾讯云ASR API调用（保留用于非实时场景）
    async callTencentASR(audioBlob) {
        try {
            // 将音频Blob转换为Base64
            const base64Audio = await this.blobToBase64(audioBlob);
            
            // 构建请求参数
            const params = {
                EngineModelType: this.config.TENCENT_ASR.engineModelType,
                ChannelNum: 1,
                ResTextFormat: 0,
                SourceType: 1,
                Data: base64Audio,
                SpeakerDiarization: 0,
                FilterDirty: this.config.TENCENT_ASR.filterDirty,
                FilterModal: this.config.TENCENT_ASR.filterModal,
                FilterPunc: this.config.TENCENT_ASR.filterPunc,
                ConvertNumMode: this.config.TENCENT_ASR.convertNumMode
            };

            // 生成签名
            const signature = this.generateTencentSignature(params);
            
            // 发送请求
            const response = await fetch(`http://127.0.0.1:3001`, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                    'Authorization': signature,
                    'X-TC-Action': 'SentenceRecognition',
                    'X-TC-Version': this.config.TENCENT_ASR.version,
                    'X-TC-Region': this.config.TENCENT_ASR.region
                },
                body: JSON.stringify(params)
            });

            if (!response.ok) {
                throw new Error(`腾讯ASR API错误: ${response.status}`);
            }

            const result = await response.json();
            
            if (result.Response && result.Response.Result) {
                return result.Response.Result;
            } else {
                console.warn('腾讯ASR返回结果为空');
                return '';
            }

        } catch (error) {
            console.error('腾讯ASR调用失败:', error);
            // 返回模拟数据用于测试
            return this.getMockTranscript();
        }
    }

    // ChatGPT API调用
    async callChatGPT(transcript) {
        try {
            const prompt = this.buildSummaryPrompt(transcript);
            
            const response = await fetch(`${this.config.CHATGPT.baseURL}/chat/completions`, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                    'Authorization': `Bearer ${this.config.CHATGPT.apiKey}`
                },
                body: JSON.stringify({
                    model: this.config.CHATGPT.model,
                    messages: [
                        {
                            role: 'system',
                            content: '你是一个专业的会议助手，擅长分析会议内容并生成结构化的会议总结。'
                        },
                        {
                            role: 'user',
                            content: prompt
                        }
                    ],
                    max_tokens: this.config.CHATGPT.maxTokens,
                    temperature: this.config.CHATGPT.temperature
                })
            });

            if (!response.ok) {
                throw new Error(`ChatGPT API错误: ${response.status}`);
            }

            const result = await response.json();
            
            if (result.choices && result.choices[0] && result.choices[0].message) {
                const content = result.choices[0].message.content;
                return this.parseSummaryResponse(content);
            } else {
                throw new Error('ChatGPT返回结果格式错误');
            }

        } catch (error) {
            console.error('ChatGPT调用失败:', error);
            // 返回模拟数据用于测试
            return this.getMockSummary();
        }
    }

    // 构建会议总结提示词
    buildSummaryPrompt(transcript) {
        return `请分析以下会议转写内容，并生成结构化的会议总结。请按照以下格式返回JSON数据：

{
    "meetingSummary": "会议总体概述",
    "keyPoints": ["关键要点1", "关键要点2", "关键要点3"],
    "actionItems": ["行动项1", "行动项2", "行动项3"],
    "nextMeeting": "下次会议安排"
}

会议转写内容：
${transcript}

请确保返回的是有效的JSON格式，不要包含其他文字。`;
    }

    // 解析ChatGPT返回的总结内容
    parseSummaryResponse(content) {
        try {
            // 尝试提取JSON部分
            const jsonMatch = content.match(/\{[\s\S]*\}/);
            if (jsonMatch) {
                return JSON.parse(jsonMatch[0]);
            } else {
                throw new Error('无法解析JSON格式');
            }
        } catch (error) {
            console.error('解析总结内容失败:', error);
            return this.getMockSummary();
        }
    }

    // 生成腾讯云API签名
    generateTencentSignature(params) {
        // 这里需要实现腾讯云的签名算法
        // 由于签名算法比较复杂，这里返回一个占位符
        // 实际使用时需要实现完整的签名逻辑
        return 'PLACEHOLDER_SIGNATURE';
    }

    // 将Blob转换为Base64
    blobToBase64(blob) {
        return new Promise((resolve, reject) => {
            const reader = new FileReader();
            reader.onload = () => {
                const base64 = reader.result.split(',')[1];
                resolve(base64);
            };
            reader.onerror = reject;
            reader.readAsDataURL(blob);
        });
    }

    // 获取模拟转写数据（用于测试）
    getMockTranscript() {
        const mockTranscripts = [
            '大家好，欢迎参加今天的项目评审会议。',
            '我们今天主要讨论三个核心议题。',
            '首先是关于项目进度的详细汇报。',
            '其次是预算分配和资源调配的问题。',
            '最后是下个月的工作计划和里程碑设定。',
            '请大家积极发言，提出宝贵的意见和建议。',
            '项目目前进展顺利，预计能够按时完成。',
            '但是需要关注一些潜在的风险点。',
            '建议增加测试环节，确保产品质量。',
            '预算方面需要重新评估，确保关键环节有足够资金。'
        ];
        
        return mockTranscripts[Math.floor(Math.random() * mockTranscripts.length)];
    }

    // 获取模拟总结数据（用于测试）
    getMockSummary() {
        return {
            meetingSummary: '本次项目评审会议主要围绕项目进度、预算分配和未来工作计划三个核心议题展开讨论。会议气氛积极，与会人员充分交流了意见。',
            keyPoints: [
                '项目进度：当前项目按计划推进，预计能够按时完成第一阶段目标',
                '预算分配：需要重新评估预算分配方案，确保关键环节有足够资金支持',
                '风险管控：识别出几个潜在风险点，需要制定相应的应对措施',
                '质量保证：建议增加测试环节，确保最终产品质量符合要求'
            ],
            actionItems: [
                '张三负责在下周前完成项目进度报告的详细整理',
                '李四负责制定预算调整方案，下周三前提交',
                '王五负责制定下月工作计划的详细实施细则',
                '赵六负责风险评估报告的编写，下周五前完成'
            ],
            nextMeeting: '下次会议定于下周五下午2点，主要讨论预算调整方案的实施细节和风险评估结果'
        };
    }

    // 检查API配置是否完整
    checkConfiguration() {
        const issues = [];
        
        if (!this.config.TENCENT_ASR.secretId || this.config.TENCENT_ASR.secretId === 'YOUR_TENCENT_SECRET_ID') {
            issues.push('请配置腾讯云ASR的SecretId');
        }
        
        if (!this.config.TENCENT_ASR.secretKey || this.config.TENCENT_ASR.secretKey === 'YOUR_TENCENT_SECRET_KEY') {
            issues.push('请配置腾讯云ASR的SecretKey');
        }
        
        if (!this.config.CHATGPT.apiKey || this.config.CHATGPT.apiKey === 'YOUR_OPENAI_API_KEY') {
            issues.push('请配置OpenAI API Key');
        }
        
        return issues;
    }
}

// 导出API服务类
if (typeof module !== 'undefined' && module.exports) {
    module.exports = APIService;
} else {
    window.APIService = APIService;
}
